package org.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.stream.Collectors;

public class Function_Demo3 {
    //方法引用
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张三,13", "张守元,14", "王行之,15", "张由心,16");
        List<Student> newlist = list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String name = s.split(",")[0];
                int age = Integer.parseInt(s.split(",")[1]);
                return new Student(name, age);
            }
        }).collect(Collectors.toList());
        System.out.println(newlist);
        System.out.println("----------------1");
        List<Student> newlist2 = list.stream().map(Student::new).collect(Collectors.toList());
        //构造方法结束后生成的对象跟抽象方法返回值保持一致

        //类名::成员方法
        ArrayList<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"aaa","www","fff");
        list2.stream().map(String::toUpperCase).forEach(System.out::println);
        //流中每个元素调用String类中的toUpperCase方法
        System.out.println("----------------2");
        //数组类型::new
        ArrayList<Integer> list3 = new ArrayList<>();
        Collections.addAll(list3,1,2,3);
        Integer []arr= list3.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr));
        System.out.println("----------------3");
        List<Integer> newlist3 = Arrays.stream(list3.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int i) {
                return new Integer[i];
            }
        })).collect(Collectors.toList());
        System.out.println(newlist3);
        //方法引用时需要注意的事项
        //1.方法引用的参数和返回值需要跟抽象方法的参数和返回值类型一致
        //2.函数式接口 3.方法存在
        /*
        1.引用静态方法  类名：：静态方法
        2.引用成员方法  对象::方法名，          this::方法 ->本类 super::方法 ->父类（静态方法中不能用）
        3.引用构造方法  类名::new
        4.引用数组构造方法  数组类型[]::new
        5.使用类名引用成员方法  类名::成员方法（不能引用所有类中成员方法，
        如果抽象方法第一个参数是A类型，那么只能引用A类中方法）
        */
    }
}
